// 音乐应用主文件

// 音乐数据存储
let musicData = [];
let currentMusicIndex = -1;
let isPlaying = false;
// 播放模式：0-列表循环，1-单曲循环，2-随机播放
let playMode = 0;
const PLAY_MODE = {
    LIST_LOOP: 0,
    SINGLE_LOOP: 1,
    RANDOM: 2
};

// DOM元素
const audio = document.getElementById('audio');
const musicListElement = document.getElementById('music-list');
const currentTitleElement = document.getElementById('current-title');
const currentArtistElement = document.getElementById('current-artist');
const currentCoverElement = document.getElementById('current-cover');
const playlistSidebar = document.getElementById('playlist-sidebar');
const togglePlaylistBtn = document.getElementById('toggle-playlist-btn');
const showPlaylistBtn = document.getElementById('show-playlist-btn');
const closePlaylistBtn = document.getElementById('close-playlist-btn');
const contentWrapper = document.querySelector('.content-wrapper');

// 初始化应用
function initApp() {
    // 加载音乐数据
    loadMusicData();
    
    // 为音频元素添加事件监听
    audio.addEventListener('ended', playNext);
    audio.addEventListener('error', handleAudioError);
    
    // 初始化拖放上传功能
    initDragAndDrop();
    
    // 获取播放模式按钮并添加事件监听
    const playModeBtn = document.getElementById('play-mode-btn');
    if (playModeBtn) {
        playModeBtn.addEventListener('click', togglePlayMode);
        // 初始化播放模式图标
        updatePlayModeIcon();
    }
    
    // 添加播放列表控制事件
    if (togglePlaylistBtn) {
        togglePlaylistBtn.addEventListener('click', togglePlaylist);
    }
    
    if (showPlaylistBtn) {
        showPlaylistBtn.addEventListener('click', togglePlaylist);
    }
    
    if (closePlaylistBtn) {
        closePlaylistBtn.addEventListener('click', togglePlaylist);
    }
    
    // 初始化时显示播放列表
    if (playlistSidebar) {
        playlistSidebar.style.transform = 'translateX(0)';
    }
    
    if (contentWrapper) {
        contentWrapper.style.transform = 'translateX(250px)';
    }
}

// 切换播放列表显示/隐藏
function togglePlaylist() {
    if (!playlistSidebar || !contentWrapper) return;
    
    // 检查当前播放列表的状态
    const isVisible = playlistSidebar.style.transform === 'translateX(0px)';
    
    // 切换播放列表和主内容区的位置
    if (isVisible) {
        // 隐藏播放列表
        playlistSidebar.style.transform = 'translateX(-250px)';
        contentWrapper.style.transform = 'translateX(0)';
    } else {
        // 显示播放列表
        playlistSidebar.style.transform = 'translateX(0)';
        contentWrapper.style.transform = 'translateX(250px)';
    }
}

// 切换播放模式
function togglePlayMode() {
    // 循环切换三种播放模式
    playMode = (playMode + 1) % 3;
    
    // 更新播放模式图标
    updatePlayModeIcon();
    
    // 显示播放模式提示
    showPlayModeTip();
}

// 更新播放模式图标
function updatePlayModeIcon() {
    const playModeBtn = document.getElementById('play-mode-btn');
    if (!playModeBtn) return;
    
    const icon = playModeBtn.querySelector('i');
    if (!icon) return;
    
    // 根据播放模式设置不同的图标
    switch (playMode) {
        case PLAY_MODE.LIST_LOOP:
            icon.className = 'fas fa-redo';
            break;
        case PLAY_MODE.SINGLE_LOOP:
            icon.className = 'fas fa-redo-alt';
            break;
        case PLAY_MODE.RANDOM:
            icon.className = 'fas fa-random';
            break;
    }
}

// 显示播放模式提示
function showPlayModeTip() {
    // 播放模式提示文本
    const tips = ['列表循环', '单曲循环', '随机播放'];
    const currentTip = tips[playMode];
    
    // 检查是否已存在提示元素
    let modeTip = document.getElementById('play-mode-tip');
    
    if (!modeTip) {
        // 创建提示元素
        modeTip = document.createElement('div');
        modeTip.id = 'play-mode-tip';
        modeTip.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background-color: rgba(0, 0, 0, 0.7);
            color: white;
            padding: 15px 25px;
            border-radius: 25px;
            font-size: 16px;
            z-index: 9999;
            opacity: 0;
            transition: opacity 0.3s ease;
        `;
        document.body.appendChild(modeTip);
    }
    
    // 设置提示文本
    modeTip.textContent = `当前播放模式: ${currentTip}`;
    
    // 显示提示
    modeTip.style.opacity = '1';
    
    // 2秒后隐藏
    setTimeout(() => {
        modeTip.style.opacity = '0';
    }, 2000);
    
    console.log(`当前播放模式: ${currentTip}`);
}

// 初始化拖放上传功能
function initDragAndDrop() {
    const dropArea = document.getElementById('drop-area');
    if (!dropArea) return;
    
    // 拖放事件处理
    ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
        dropArea.addEventListener(eventName, preventDefaults, false);
    });
    
    function preventDefaults(e) {
        e.preventDefault();
        e.stopPropagation();
    }
    
    // 高亮效果
    ['dragenter', 'dragover'].forEach(eventName => {
        dropArea.addEventListener(eventName, highlight, false);
    });
    
    ['dragleave', 'drop'].forEach(eventName => {
        dropArea.addEventListener(eventName, unhighlight, false);
    });
    
    function highlight() {
        dropArea.classList.add('dragover');
    }
    
    function unhighlight() {
        dropArea.classList.remove('dragover');
    }
    
    // 处理文件拖放
    dropArea.addEventListener('drop', handleDrop, false);
    
    function handleDrop(e) {
        const dt = e.dataTransfer;
        const files = dt.files;
        
        handleFiles(files);
    }
    
    // 处理选择的文件
    function handleFiles(files) {
        if (files.length === 0) return;
        
        // 检查文件类型
        const validFiles = Array.from(files).filter(file => {
            const extension = file.name.split('.').pop().toLowerCase();
            return ['mp3', 'flac', 'wav', 'm4a', 'aac', 'ogg', 'wma', 'aiff', 'aif', 'alac', 'mp4'].includes(extension);
        });
        
        if (validFiles.length === 0) {
            showNotification('请选择支持的音频文件格式（MP3、FLAC、WAV、M4A、AAC、OGG、WMA、AIFF、ALAC、MP4）');
            return;
        }
        
        // 显示上传通知
        showNotification(`开始上传 ${validFiles.length} 个文件...`);
        
        // 创建FormData并上传
        const formData = new FormData();
        validFiles.forEach(file => {
            formData.append('files', file);
        });
        
        // 发送上传请求
        fetch('/music/upload', {
            method: 'POST',
            body: formData
        }).then(response => {
            if (!response.ok) {
                throw new Error('上传失败');
            }
            return response.json();
        }).then(data => {
            showNotification('上传成功！正在刷新音乐列表...');
            // 重新加载音乐列表
            setTimeout(loadMusicData, 1000);
        }).catch(error => {
            console.error('上传错误:', error);
            showNotification('上传失败，请重试');
        });
    }
    
    // 添加点击上传功能
    dropArea.addEventListener('click', () => {
        const fileInput = document.createElement('input');
        fileInput.type = 'file';
        fileInput.accept = '.mp3,.flac,.wav,.m4a,.aac,.ogg,.wma,.aiff,.aif,.alac,.mp4';
        fileInput.multiple = true;
        fileInput.style.display = 'none';
        
        fileInput.addEventListener('change', (e) => {
            handleFiles(e.target.files);
        });
        
        document.body.appendChild(fileInput);
        fileInput.click();
        document.body.removeChild(fileInput);
    });
}

// 从后端API加载音乐数据
function loadMusicData() {
    // 通过API从后端获取音乐数据
    const baseUrl = config.apiBaseUrl;
    console.log('尝试加载音乐数据，请求URL:', baseUrl + '/music');
    fetch(baseUrl + '/music')
        .then(response => {
            console.log('响应状态码:', response.status);
            if (!response.ok) {
                throw new Error('网络响应错误: ' + response.status);
            }
            return response.json();
        })
        .then(data => {
            console.log('获取到的音乐数据数量:', data.length);
            console.log('获取到的音乐数据示例:', data.length > 0 ? data[0] : '无数据');
            musicData = data;
            // 渲染音乐列表
            renderMusicList();
        })
        .catch(error => {
            console.error('加载音乐数据失败:', error);
            // 出错时使用模拟数据进行测试
            musicData = [
                {
                    id: 1,
                    title: '测试音乐1',
                    artist: '测试艺术家1',
                    audioUrl: '/music/川青 - 下潜/川青 - 下潜.flac',
                    coverUrl: null,
                    lyricsUrl: '/music/川青 - 下潜/川青 - 下潜.lrc'
                },
                {
                    id: 2,
                    title: '测试音乐2',
                    artist: '测试艺术家2',
                    audioUrl: '/music/撒野 - 凯瑟喵/撒野 - 凯瑟喵.flac',
                    coverUrl: '/music/撒野 - 凯瑟喵/撒野 - 凯瑟喵.jpg',
                    lyricsUrl: '/music/撒野 - 凯瑟喵/撒野 - 凯瑟喵.lrc'
                }
            ];
            console.log('使用模拟数据进行测试');
            renderMusicList();
        });
}

// 渲染音乐列表 - 优化性能和用户体验
function renderMusicList() {
    // 清空列表
    musicListElement.innerHTML = '';
    
    if (musicData.length === 0) {
        // 显示没有找到音乐文件的提示
        const emptyMessage = document.createElement('div');
        emptyMessage.classList.add('empty-message');
        emptyMessage.innerHTML = `
            <div class="empty-icon">🎵</div>
            <div class="empty-text">没有找到音乐文件</div>
            <div class="empty-subtext">请按照要求的结构在音乐目录中添加音乐文件</div>
        `;
        musicListElement.appendChild(emptyMessage);
    } else {
        // 使用文档片段优化性能
        const fragment = document.createDocumentFragment();
        
        // 根据屏幕宽度调整渲染策略
        const isMobile = window.innerWidth <= 768;
        
        // 渲染音乐列表
        musicData.forEach((music, index) => {
            const musicItem = document.createElement('div');
            musicItem.classList.add('music-item');
            
            if (index === currentMusicIndex) {
                musicItem.classList.add('active');
            }
            
            // 处理空艺术家情况，确保显示合理内容
            const displayArtist = music.artist || '未知艺术家';
            
            // 使用模板字符串创建HTML内容
            musicItem.innerHTML = `
                <img src="${music.coverUrl || '../assets/default-cover.svg'}" alt="${music.title} 封面" loading="lazy">
                <div class="music-info">
                    <div class="music-title">${music.title}</div>
                    <div class="music-artist">${displayArtist}</div>
                </div>
                <div class="music-duration">${music.duration ? formatTime(music.duration) : ''}</div>
            `;
            
            // 添加点击事件处理
            musicItem.addEventListener('click', () => {
                // 为移动设备添加触摸反馈
                if (isMobile) {
                    musicItem.style.backgroundColor = 'rgba(0, 122, 255, 0.1)';
                    setTimeout(() => {
                        musicItem.style.backgroundColor = '';
                    }, 150);
                }
                
                playMusic(index);
            });
            
            // 添加到文档片段
            fragment.appendChild(musicItem);
        });
        
        // 一次性添加所有元素到DOM
        musicListElement.appendChild(fragment);
        
        // 如果有当前播放的音乐，确保它在可视区域内
        if (currentMusicIndex >= 0) {
            setTimeout(() => {
                const activeElement = musicListElement.querySelector('.music-item.active');
                if (activeElement) {
                    activeElement.scrollIntoView({ 
                        behavior: 'smooth', 
                        block: 'nearest',
                        inline: 'nearest'
                    });
                }
            }, 100);
        }
    }
}

// 更新音乐列表中的活动项
function updateActiveMusicItem(newIndex) {
    const oldActive = musicListElement.querySelector('.music-item.active');
    if (oldActive) {
        oldActive.classList.remove('active');
    }
    
    if (newIndex >= 0 && newIndex < musicData.length) {
        const newActive = musicListElement.children[newIndex];
        if (newActive && newActive.classList.contains('music-item')) {
            newActive.classList.add('active');
            
            // 平滑滚动到当前活动项
            newActive.scrollIntoView({ 
                behavior: 'smooth', 
                block: 'nearest',
                inline: 'nearest'
            });
        }
    }
}

// 格式化时间显示
function formatTime(seconds) {
    if (!seconds || isNaN(seconds)) return '0:00';
    const minutes = Math.floor(seconds / 60);
    const remainingSeconds = Math.floor(seconds % 60);
    return `${minutes}:${remainingSeconds < 10 ? '0' : ''}${remainingSeconds}`;
}

// 播放指定索引的音乐 - 添加平滑过渡效果
function playMusic(index) {
    if (index < 0 || index >= musicData.length) {
        return;
    }
    
    // 保存旧索引
    const oldIndex = currentMusicIndex;
    
    // 更新当前音乐索引
    currentMusicIndex = index;
    
    // 更新活动项，避免重新渲染整个列表
    updateActiveMusicItem(index);
    
    // 添加切换动画
    const playerContainer = document.querySelector('.player-container');
    const albumCover = document.querySelector('.album-cover');
    
    // 淡出动画
    playerContainer.style.opacity = '0.5';
    if (albumCover) {
        albumCover.style.transform = 'scale(0.95)';
    }
    
    const music = musicData[index];
    currentMusicIndex = index;
    
    // 更新音频源 - 使用基于后端服务的URL
    console.log('尝试播放的音频URL:', music.audioUrl);
    // 构建完整的后端服务URL来播放音乐
    const baseUrl = 'http://localhost:15001';
    
    // 注意：后端使用/static-music路径提供音乐文件访问，而不是/music
    // 我们需要将audioUrl中的/music前缀替换为/static-music
    const audioPath = music.audioUrl.replace('/music/', '/static-music/');
    audio.src = `${baseUrl}${audioPath}`;

    // 更新歌曲信息
    currentTitleElement.textContent = music.title;
    currentArtistElement.textContent = music.artist || '未知艺术家';
    
    // 更新迷你播放器信息
    const miniTitleEl = document.getElementById('mini-title');
    const miniArtistEl = document.getElementById('mini-artist');
    const miniCoverEl = document.getElementById('mini-cover');
    if (miniTitleEl && miniArtistEl) {
        miniTitleEl.textContent = music.title;
        miniArtistEl.textContent = music.artist || '未知艺术家';
    }
    if (miniCoverEl) {
        const baseUrl = 'http://localhost:15001';
        if (music.coverUrl) {
            // 替换封面URL中的/music前缀为/static-music
            const coverPath = music.coverUrl.replace('/music/', '/static-music/');
            miniCoverEl.src = `${baseUrl}${coverPath}`;
        } else {
            miniCoverEl.src = '../assets/default-cover.svg';
        }
        miniCoverEl.alt = music.title + ' 封面';
    }
    
    // 为封面添加加载动画
    if (currentCoverElement) {
        currentCoverElement.style.opacity = '0';
        if (music.coverUrl) {
            // 替换封面URL中的/music前缀为/static-music
            const coverPath = music.coverUrl.replace('/music/', '/static-music/');
            currentCoverElement.src = `${baseUrl}${coverPath}`;
        } else {
            currentCoverElement.src = '../assets/default-cover.svg';
        }
        
        // 图片加载完成后显示
        currentCoverElement.onload = function() {
            currentCoverElement.style.opacity = '1';
        };
    }
    
    // 智能生成歌词URL - 针对同文件夹下的LRC文件
    let lyricsUrl = music.lyricsUrl;
    
    // 如果没有明确的歌词URL，尝试从音频URL生成可能的歌词URL
    if (!lyricsUrl && music.audioUrl) {
        // 尝试同文件夹下的同名LRC文件
        lyricsUrl = music.audioUrl.replace(/\.[^/.]+$/, '.lrc');
        console.log('尝试生成的歌词URL:', lyricsUrl);
    }
    
    // 修正歌词URL的路径前缀
    if (lyricsUrl) {
        // 将/music前缀替换为/static-music
        lyricsUrl = lyricsUrl.replace('/music/', '/static-music/');
    }
    
    // 加载歌词
    loadLyrics(lyricsUrl);
    
    // 播放音乐
    audio.play().then(() => {
        isPlaying = true;
        updatePlayButton();
        
        // 淡入动画
        setTimeout(() => {
            playerContainer.style.opacity = '1';
            if (albumCover) {
                albumCover.style.transform = 'scale(1)';
            }
        }, 300);
    }).catch(error => {
        console.error('播放失败:', error);
        // 恢复动画状态
        playerContainer.style.opacity = '1';
        if (albumCover) {
            albumCover.style.transform = 'scale(1)';
        }
        
        // 使用更友好的提示方式
        showNotification('播放失败，请检查网络或文件是否存在');
    });
    
    // 更新音乐列表选中状态
    renderMusicList();
}

// 显示通知提示
function showNotification(message) {
    // 检查是否已存在通知元素
    let notification = document.getElementById('notification');
    
    if (!notification) {
        // 创建通知元素
        notification = document.createElement('div');
        notification.id = 'notification';
        notification.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            background-color: rgba(0, 0, 0, 0.7);
            color: white;
            padding: 15px 25px;
            border-radius: 25px;
            font-size: 14px;
            z-index: 9999;
            opacity: 0;
            transition: opacity 0.3s ease;
        `;
        document.body.appendChild(notification);
    }
    
    // 设置消息并显示
    notification.textContent = message;
    notification.style.opacity = '1';
    
    // 3秒后隐藏
    setTimeout(() => {
        notification.style.opacity = '0';
    }, 3000);
}

// 播放/暂停当前音乐
function togglePlay() {
    if (currentMusicIndex === -1) {
        // 如果没有选中的音乐，默认播放第一首
        if (musicData.length > 0) {
            playMusic(0);
        }
        return;
    }
    
    if (isPlaying) {
        audio.pause();
    } else {
        audio.play();
    }
    
    isPlaying = !isPlaying;
    updatePlayButton();
}

// 更新播放按钮状态
function updatePlayButton() {
    const playBtn = document.getElementById('play-btn');
    if (playBtn) {
        playBtn.innerHTML = isPlaying ? '<i class="fas fa-pause"></i>' : '<i class="fas fa-play"></i>';
    }
}

// 播放下一首
function playNext() {
    if (musicData.length === 0) {
        return;
    }
    
    let nextIndex = currentMusicIndex;
    
    // 根据播放模式确定下一首歌曲的索引
    switch (playMode) {
        case PLAY_MODE.LIST_LOOP:
            // 列表循环：播放到最后一首时回到第一首
            nextIndex = (currentMusicIndex + 1) % musicData.length;
            break;
        case PLAY_MODE.SINGLE_LOOP:
            // 单曲循环：始终播放当前歌曲
            nextIndex = currentMusicIndex;
            break;
        case PLAY_MODE.RANDOM:
            // 随机播放：随机选择下一首歌曲，确保不与当前歌曲相同（如果至少有2首歌）
            if (musicData.length > 1) {
                do {
                    nextIndex = Math.floor(Math.random() * musicData.length);
                } while (nextIndex === currentMusicIndex);
            }
            break;
    }
    
    playMusic(nextIndex);
}

// 播放上一首
function playPrevious() {
    if (musicData.length === 0) {
        return;
    }
    
    let prevIndex = currentMusicIndex;
    
    // 根据播放模式确定上一首歌曲的索引
    switch (playMode) {
        case PLAY_MODE.LIST_LOOP:
            // 列表循环：播放到第一首时回到最后一首
            prevIndex = currentMusicIndex - 1;
            if (prevIndex < 0) {
                prevIndex = musicData.length - 1; // 循环播放
            }
            break;
        case PLAY_MODE.SINGLE_LOOP:
            // 单曲循环：始终播放当前歌曲
            prevIndex = currentMusicIndex;
            break;
        case PLAY_MODE.RANDOM:
            // 随机播放：随机选择上一首歌曲，确保不与当前歌曲相同（如果至少有2首歌）
            if (musicData.length > 1) {
                do {
                    prevIndex = Math.floor(Math.random() * musicData.length);
                } while (prevIndex === currentMusicIndex);
            }
            break;
    }
    
    playMusic(prevIndex);
}

// 加载歌词
function loadLyrics(lyricsUrl) {
    // 在实际项目中，这里应该通过API获取歌词文件
    // 由于是模拟环境，我们使用模拟歌词
    if (typeof window.loadLyricsFromUrl === 'function') {
        window.loadLyricsFromUrl(lyricsUrl);
    }
}

// 处理音频错误
function handleAudioError() {
    console.error('音频播放错误:', audio.error);
    
    // 获取更详细的错误信息
    let errorMessage = '音频播放错误';
    if (audio.error) {
        switch(audio.error.code) {
            case audio.error.MEDIA_ERR_ABORTED:
                errorMessage = '播放被中止';
                break;
            case audio.error.MEDIA_ERR_NETWORK:
                errorMessage = '网络错误导致播放失败';
                break;
            case audio.error.MEDIA_ERR_DECODE:
                errorMessage = '音频文件格式不支持或损坏';
                break;
            case audio.error.MEDIA_ERR_SRC_NOT_SUPPORTED:
                errorMessage = '音频源不支持或URL错误';
                break;
            default:
                errorMessage = '未知的音频播放错误';
        }
    }
    
    console.error('详细错误信息:', errorMessage);
    showNotification(errorMessage);
    isPlaying = false;
    updatePlayButton();
}

// 导出公共方法
window.app = {
    init: initApp,
    playMusic: playMusic,
    togglePlay: togglePlay,
    playNext: playNext,
    playPrevious: playPrevious,
    getMusicData: () => musicData,
    getCurrentMusicIndex: () => currentMusicIndex
};

// 页面加载完成后初始化应用
window.addEventListener('DOMContentLoaded', app.init);